/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */
package controlador;

import excepciones.NonexistentEntityException;
import excepciones.PreexistingEntityException;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import negocio.*;
import persistencia.*;

/**
 *
 * @author Diego
 */
public class CtrlPersistencia {
    
    private static final ComplejoJpaController complejoControlador;
    private static final ButacaJpaController butacaControlador;
    private static final EventoJpaController eventoControlador;
    private static final FilaJpaController filaControlador;
    private static final FuncionJpaController funcionControlador;
    private static final SalaJpaController salaControlador;
    private static final SeccionJpaController seccionControlador ;
    private static final TarifaJpaController tarifaControlador;
    private static final TicketJpaController ticketControlador;
    private static final TransaccionVentasJpaController transaccionVentasControlador;
    private static final UsuarioJpaController usuarioControlador;
    
    static {        
        complejoControlador = new ComplejoJpaController();
        butacaControlador = new ButacaJpaController();
        eventoControlador = new EventoJpaController();
        filaControlador = new FilaJpaController();
        funcionControlador = new FuncionJpaController();
        salaControlador = new SalaJpaController();
        seccionControlador = new SeccionJpaController();
        tarifaControlador = new TarifaJpaController();
        ticketControlador = new TicketJpaController();
        transaccionVentasControlador = new TransaccionVentasJpaController();
        usuarioControlador = new UsuarioJpaController();
    }
    
    /* Butaca */
    public static void crearButaca(Butaca unaButaca) throws Exception{
        butacaControlador.create(unaButaca);
    }
    public static void modificarButaca(Butaca unaButaca) throws Exception{
        butacaControlador.edit(unaButaca);
    }
    public static void borrarButaca(Integer id) throws NonexistentEntityException{
        butacaControlador.destroy(id);
    }
    /* Fin Butaca */
    
    /* Complejo */
    public static void crearComplejo(Complejo unComplejo) throws PreexistingEntityException, Exception {
        complejoControlador.create(unComplejo);
    }
    public static void modificarComplejo(Complejo unComplejo) throws NonexistentEntityException, Exception {
        complejoControlador.edit(unComplejo);
    }
    public static Complejo mostrarComplejo() throws NonexistentEntityException, Exception {
        /**
        * Transformamos la lista que devuelve jpa en un Map
        **/
        Complejo auxComplejo = new Complejo();
        
        Iterator it = complejoControlador.findComplejoEntities().iterator();
        
        while(it.hasNext()){
            auxComplejo = (Complejo) it.next();
        }
        return auxComplejo;
    }     
    public static int maxSalaID() {
     return complejoControlador.getSalaCount();
    }
    public static int maxEventoID() {
        return complejoControlador.getEventoCount();
    }
    public static Integer maxUsuarioId(){
        return usuarioControlador.getUsuarioCount();
    }
    public static int maxTransaccionVentasID() {
        return complejoControlador.getTransaccionVentasCount();
    }    
    /* Fin Complejo */
    
    /* Evento */
    public static void crearEvento(Evento unEvento) throws Exception{
        eventoControlador.create(unEvento);
    }
    public static void borrarEvento(Integer id) throws NonexistentEntityException{
        eventoControlador.destroy(id);
    }
    public static void modificarEvento(Evento evento){
        eventoControlador.edit(evento);
    }
    public static Set<Evento> listaDeEventos(){
        Set<Evento> lista = new HashSet();
        Evento eventoAux;
        Iterator it = eventoControlador.findEventoEntities().iterator();
        while(it.hasNext()){
            eventoAux = (Evento) it.next();
            lista.add(eventoAux);                    
        }
        return lista;
    }
    public static Integer maxEventoId(){
        return eventoControlador.getEventoCount();
    }
    /* Fin Evento */
    
    /* Fila */
    public static Set<Fila>listaDeFilas(Seccion unaSeccion){
        Set<Fila> lista = new HashSet();
        Fila auxFila;
        Iterator it = filaControlador.findFilaEntities(unaSeccion).iterator();
        while(it.hasNext()){
            auxFila = (Fila) it.next();
            lista.add(auxFila);
        }
        return lista;
    } 
    public static Set<Fila>listaDeFilasActivas(Seccion unaSeccion){
        Set<Fila> lista = new HashSet();
        Fila auxFila;
        Iterator it = filaControlador.findFilaEntities(unaSeccion).iterator();
        while(it.hasNext()){
            auxFila = (Fila) it.next();
            if(auxFila.isEstado()){
                lista.add(auxFila);
            }
        }
        return lista;
    }
    public static Set<Butaca> listaDeButacas(Fila unaFila){
        Set<Butaca> lista  = new HashSet();
        Butaca butacaAux;
        Iterator it = butacaControlador.findFilaEntities(unaFila).iterator();
        while (it.hasNext()){
            butacaAux = (Butaca) it.next();
            lista.add(butacaAux);
        }
        return lista;
    }
    public static void modificarFila(Fila unaFila) throws Exception{
        filaControlador.edit(unaFila);
    }
    public static void crearFila(Fila unaFila) throws Exception{
        filaControlador.create(unaFila);
    }
    public static int maxFilaId(){
       return seccionControlador.getFilaCount();
    }
    public static void borrarFila(Integer id) throws NonexistentEntityException{
        filaControlador.destroy(id);
    }
    /* Fin Fila */
    
    /* Funcion */
    public static void crearFuncion(Funcion funcion) throws PreexistingEntityException{
        funcionControlador.create(funcion);
    }
    public static void borrarFuncion (Integer id) throws NonexistentEntityException{
        funcionControlador.destroy(id);
    }
    public static void modificarFuncion(Funcion funcion){
        funcionControlador.edit(funcion);
    }
    public Set<Tarifa> listaDeTarifas(Funcion funcion){        
        Set<Tarifa> lista = new HashSet();
        Tarifa tarifa;
        Iterator it = funcionControlador.findTarifaEntities(funcion).iterator();
        while(it.hasNext()){
            tarifa = (Tarifa) it.next();
            lista.add(tarifa);
        }
        return lista;
        
    }
    public Set<TransaccionVentas> listaDeTransacciones(Funcion funcion){
        Set<TransaccionVentas> lista = new HashSet();
        TransaccionVentas transaccion;
        Iterator it = funcionControlador.findTransaccionEntities(funcion).iterator();
        while(it.hasNext()){
           transaccion = (TransaccionVentas) it.next();
           lista.add(transaccion);
        }
        return lista;
    }
    public Set<Ticket> listarTicketsVendidos(Funcion funcion){
        Set<Ticket> lista = new HashSet();
        Ticket ticket;
        Iterator it = funcionControlador.findTicketsEntities(funcion).iterator();
        while(it.hasNext()){
            ticket = (Ticket) it.next();
            lista.add(ticket);
        }
        return lista;
    }
    /* Fin Funcion */
    
    /* Sala */
    public static void crearSala(Sala unaSala)throws PreexistingEntityException, Exception{
        salaControlador.create(unaSala);
    }
    public static Set<Sala> listaDeSalas(){
        Set<Sala> lista = new HashSet();
        Sala auxSala;
        Iterator it  = salaControlador.findSalaEntities().iterator();
        while(it.hasNext()){
            auxSala = (Sala) it.next();
            lista.add(auxSala);
        }
        return lista;
    }
    public static Set<Sala> listaDeSalasActivas(){
        Set<Sala> lista = new HashSet();
        Sala auxSala;
        Iterator it  = salaControlador.findSalaEntities().iterator();
        while(it.hasNext()){
            auxSala = (Sala) it.next();
            if(auxSala.isEstado()){
                lista.add(auxSala);
            }
        }
        return lista;
    }
    public static void modificarSala(Sala unaSala) throws Exception{
        salaControlador.edit(unaSala);
    }
    public static int maxSeccionId(){
       return salaControlador.getSeccionCount();
    }
    public static void borrarSala(Integer id) throws NonexistentEntityException{
        salaControlador.destroy(id);
    }
    public static Integer maxButacaId(){
        return salaControlador.getButacaCount();
    }
    /* Fin Sala */
    
    /* Seccion */
    public static Set<Seccion> listaDeSecciones(Sala unaSala){
        Set<Seccion> lista = new HashSet();
        Seccion auxSeccion;
        Iterator it = seccionControlador.findSeccionEntities(unaSala).iterator();
        while(it.hasNext()){
            auxSeccion = (Seccion) it.next();
            lista.add(auxSeccion);
        }
        return lista;
    }
    public static Set<Seccion> listaDeSeccionesActivas(Sala unaSala){
        Set<Seccion> lista = new HashSet();
        Seccion auxSeccion;
        Iterator it = seccionControlador.findSeccionEntities(unaSala).iterator();
        while(it.hasNext()){
            auxSeccion = (Seccion) it.next();
            if(auxSeccion.isEstado()){
                lista.add(auxSeccion);
            }
        }
        return lista;
    }
    public static void crearSeccion(Seccion unaSeccion)throws PreexistingEntityException, Exception{
        seccionControlador.create(unaSeccion);
    }
    public static void modificarSeccion(Seccion unaSeccion) throws NonexistentEntityException{
        seccionControlador.edit(unaSeccion);
    }
    public static void borrarSeccion(Integer id) throws NonexistentEntityException{
        seccionControlador.destroy(id);
    }
    /* Fin Seccion */
    /* Tarifa */
    public static void crearTarifa(Tarifa tarifa) throws PreexistingEntityException{
       tarifaControlador.create(tarifa); 
    }
    public static void borrarTarifa(Integer id){
        tarifaControlador.destroy(id);
    }
    public static void modificarTarifa(Tarifa tarifa){
        tarifaControlador.edit(tarifa);
    }
    /* Fin Tarifa */
    /* Ticket */
    
    
    
    /* Fin Ticket */
    
    /* TransaccionVentas */
    public static Set<TransaccionVentas> listaDeTransaccionesDeVentas(){
        Set<TransaccionVentas> lista= new HashSet();
        TransaccionVentas var;
        Iterator it = transaccionVentasControlador.findtransaccionVentasEntities().iterator();
        while(it.hasNext()){
            var = (TransaccionVentas) it.next();
            lista.add(var);
        }
        return lista;
    }
    /* Fin TransaccionVentas */
    
    /* Usuario */
    public static void crearUsuario(Usuario unUsuario)throws PreexistingEntityException, Exception{
        usuarioControlador.create(unUsuario);
    }
    public static  Map<String,Usuario> listaDeUsuarios(){
        Map<String,Usuario> lista = new HashMap();
        Usuario usuarioAux;
        Iterator it = usuarioControlador.findUsuarioEntities().iterator();
        while(it.hasNext()){
            usuarioAux = (Usuario) it.next();
            lista.put(usuarioAux.getUserName(), usuarioAux);            
        }
        return lista;
    }
    public static void modificarUsuario(Usuario unUsuario) throws Exception{
        usuarioControlador.edit(unUsuario);
    }
    public static void borrarUsuario(String username) throws NonexistentEntityException{
        usuarioControlador.destroy(username);
    }
    /* Fin Usuario */
}
